perm filename HALREC.SAI[HAL,HE]5 blob sn#239547 filedate 1976-09-29 generic text, type C, neo UTF8
COMMENT ⊗   VALID 00006 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	header files & the like
C00004 00003	! Standard records 
C00017 00004	! data types
C00019 00005	! operators for expressions
C00023 00006	! predeclared variables & internal system variables
C00027 ENDMK
C⊗;
COMMENT header files & the like;

IFCR ¬DECLARATION(π) THENC 
	ENTRY;
	BEGIN "HALREC"

	REQUIRE "ABBREV.SAI[HAL,HE]" SOURCE_FILE;
	REQUIRE "MACROS.SAI[HAL,HE]" SOURCE_FILE;
	REQUIRE "RECAUX.HDR[HAL,HE]" SOURCE_FILE;
	REQUIRE "LEPAUX.HDR[HAL,HE]" SOURCE_FILE;
	REQUIRE "PRCAUX.HDR[HAL,HE]" SOURCE_FILE;
	REQUIRE "REFBTS.DEF[HAL,HE]" SOURCE_FILE;

	DEFINE HALRECTERNAL=[INTERNAL];
	DEFINE HALRECEND=[END];
	DEFINE HALRECSW = 1;
	DEFINE NOARITH = "TRUE";
	REQUIRE "ARITH.HDR[HAL,HE]" SOURCE_FILE;
	
ELSEC
	REQUIRE "[][]" DELIMITERS;
	REQUIRE "HALREC.REL[HAL,HE]" LOAD_MODULE;
	DEFINE HALRECEND=[  ];
	DEFINE HALRECTERNAL=[EXTERNAL];
	DEFINE HALRECSW = 0;
ENDC


! a few constants;

DEFINE INCHES = "2.54";
DEFINE DEGREES = "(π/180.0)";

HALRECTERNAL OWN INTEGER ARRAY PATCH[0:50];
! Standard records ;

DEFINE HALRTYPE(FOO,BAR) "<>" =
	< ASSIGNC BAR = CVPS(FOO)&"TYPE";
	  REDEFINE NHRECS=NHRECS+1;
	  DEFINE BAR = NHRECS>;
DEFINE HALRCLASS(FOO) "<>" = 
	< HALRTYPE(FOO);
	  HALRECTERNAL RECORD_CLASS FOO >;

DEFINE NHRECS=0;
	
IFCR ¬DECLARATION(_FACT_) THENC
	EXTERNAL RECORD_CLASS FACT(integer fake);
	ENDC

	DEFINE RCELL = [RPTR(CELL)];
	DEFINE REXPR = [RANY];
	DEFINE RVAR = [RPTR(VARIABLE)];
	DEFINE RSTMNT = [RPTR(STMNT)];
	DEFINE RSSS = [RANY];


	! Constants.  **** Now, record classes defined by ARITH ****;
	HALRCLASS (STCONST) (STRING ITEMVAR VAL);

	HALRTYPE(V3ECT);
	HALRTYPE(ROTN);
	HALRTYPE(TRANS);
	HALRTYPE(SVAL);
	HALRTYPE(TINFO);
	HALRTYPE(FRAME);

	! a special sort of locus expression;

	HALRCLASS (BPARAM) (REAL MXV,MNV,NV;INTEGER ROLE;RANY SEMANTICS);

	! expressions;

	HALRCLASS (EXPRN) (INTEGER DATATYPE,OP;RCELL ARGS);

	! Variables & their attributes;
				
	HALRCLASS (FLUENT) (RPTR(FACT) FACTID;RANY FREC,RETRPATT);
	HALRCLASS (SET_FLUENT) (RANY RETRPATT);
	HALRCLASS (VNODE) (INTEGER INVMARK;RPTR(VALU$) NOMVAL);
	HALRCLASS (LBLVAR) (RANY ITEMVAR NAME;
				INTEGER DATATYPE;RANY BLK;RANY SEMANTICS);
	HALRCLASS (VARIABLE) (RANY ITEMVAR NAME;INTEGER DATATYPE, OFFSET;
					RANY SEMANTICS;
					RPTR(FLUENT) PLNVAL;
					RPTR(SET_FLUENT) CALCS,DEPS,CHANGERS;
		!  Temp for RF:;	RANY VAL;
					INTEGER ATTRIBUTES;
					RANY BLK);
		! Variable attribute bits follow:   ;
		BITDEF(GLBAL,'1);  ! This variable is declared "global";
		! BLK is block in which this variable appears;

	! Control structures;

	HALRCLASS (STMNT)(RANY ITEMVAR ID;ITEMVAR IW,OW,PRC;RSSS SEMANTICS;
			INTEGER STLAB);


	HALRCLASS (PROG) (RPTR(STMNT) CODE);
	HALRCLASS (BLOCK) (RCELL CODE,VARS,CMONS,EVTS,CLCS,ALSOS,FORCES;
				      RANY ITEMVAR BLID;
				      RANY PARENT);
			! As used by GOBBLE, BLID⊗ident≡var;
			! CLCS,CMONS,ALSOS are all lists of the corresponding
			  constructs.

			  I am assuming (for now) that all CALCs or CHANGERs
			  are "set up" whenever their block is entered.
			  This is not strictly necessary & the work may
			  just as well be done when needed.

			  It is assumed that ALSOS & CALCS will all be
			  undone when the block is exited. In the case of
			  ALSOS, this means unlinking each changer from
			  whatever graph nodes it is linked to & freeing
			  up the storage.  In the case of CALCS, just
			  drop the pointer & allow variable killing to
			  do all the work.  I am assuming that a changer
			  will be put onto the corrrect block to govern its
			  "life". 
			;
	HALRCLASS (BLKOP) (INTEGER OP);
			! for the moment, this construct is used
			  just by WLDMOD:  The first statement in a block
			  (with declarations, etc) is BLKOP(1)
			  & the last statement is BLKOP(2).  Perhaps
			  Ray would like to use this, too;
			DEFINE ENTERBLOCK = 1;
			DEFINE LEAVEBLOCK = 2;


	HALRCLASS (CALCULATOR)(RPTR(FLUENT) PLNVAL;
			       RPTR(SET_FLUENT) DEPS;
			       SET NEEDED;REXPR FORM;INTEGER OFFSET;
			       RPTR(LBLVAR) LBL);

	HALRCLASS (CHANGER) (INTEGER OFFSET;RPTR(BLOCK) BLID;
			     RPTR(SET_FLUENT) TRIGGERS;
			     RPTR(STMNT) CODE;RPTR(LBLVAR) LBL);
			! Triggers is set of variables whose change triggers 
			  this fellow;

	HALRCLASS (COBLOCK) (RCELL CODE);
	HALRCLASS (TASKBLOCK) (RCELL CODE);
	HALRCLASS (FORR) (RVAR CONVAR; REXPR INITIAL, STEP, FINAL; RSTMNT BODY);
	HALRCLASS (WHIL) (REXPR COND; RSTMNT BODY);
	HALRCLASS (IFF) (REXPR COND; RSTMNT THN, ELS);
	HALRCLASS (PAUSE) (REXPR VAL);
	HALRCLASS (ABORT) (REXPR VAL);

	! graph structure manipulators;

	HALRCLASS (ASSIGNMENT) (RVAR VAR; REXPR VAL);
	HALRCLASS (PRNT) (REXPR VAL);
	HALRCLASS (AFFIX) (RVAR FRAME1,FRAME2,BYVAR;REXPR ATEXP;RVAR RIGID;
						RCELL GPHCODE);
	HALRCLASS (UNFIX) (RVAR FRAME1,FRAME2;RCELL GPHCODE);
			! in both these cases, GPHCODE is list of graph
			  assignments & alsodo's.  Note: NOT of
			  STMNTS.
			;

	HALRCLASS (GASSIGN)(RPTR(VARIABLE) VAR;
				INTEGER OP;RPTR(CALCULATOR,LBLVAR) CLC);
	    !  The OP has these meanings:
		1:	=	is computed by, "<="
		2:	≠	is not computed by, "<≠"
		3:	< or ←  is only computed by, "<<="
	    ;

	HALRCLASS (ALSODO)(RPTR(VARIABLE) VAR;INTEGER OP;RPTR(CHANGER,LBLVAR) CHG);
	    ! ***** CHG used to be a stmnt ****;
	    !  The OP has these meanings:
		1:	When changing VAR also do CODE
		2:	When changing VAR dont do CODE
		3:	When changing VAR only do CODE
	    ;

	HALRCLASS (SPECVAL)(BOOLEAN OLD; INTEGER TYPE);
	    ! Either OLD or NEW, can be of any type;

	HALRCLASS (EVDO)(RVAR VAR; INTEGER OP);
	    !  OP = 0 for signal, =1 for wait;

	HALRCLASS (DEXPR)(RVAR VAR;REXPR EXPN;RPTR(VALU$) VAL;RVAR TMPVAR);
		! This construct is intended as a special kluge to
		  pass destination expressions on to MOVE statements
		  & (perhaps) other PASS3 things that need planning
		  values.  VAR is assumed to be a variable whose
		  value is to be fetched at runtime.  If EXPN is
		  not null, then VAR is probably a temp.  In any event,
		  it is assumed that PASS3 will emit code to compute
		  EXPN & assign it into VAR before using.  VAL
		  is set up by the simulator & contains the planning
		  value of VAR.  TMPVAR is the same as VAR if VAR is
		  a temp.  The reason for this is that the simulator may
		  make several passes over the same statement & I
		  need a way to avoid creating duplicate temps all over
		  the place.
		;

	! quasi-statements;

	HALRCLASS (PVL)(RCELL VL;ITEMVAR WLD);
	HALRCLASS (DBD)(ITEMVAR WLD);
	HALRCLASS (NW)(ITEMVAR WLD);

	! misc statements;

	HALRCLASS (MOVE$) (RVAR WHAT;REXPR DEST;RCELL CLAUSES;RVAR CF;
				  			RPTR(DEXPR) DEXP);
	HALRCLASS (OPERATE) (RVAR WHAT;REXPR DEST;RCELL CLAUSES;RVAR CF;
				  			RPTR(DEXPR) DEXP);
		! CF is the controllable frame for this motion statement.
		  DEXP is the DEXPR that gives the ACTUAL destination for
			CF.  
		  **** At present, the program graph is NOT modified
			to generate an assignment statement into DFTEMP.
			It is assumed that the code generator will 
			generate code to evaluate the expression &
			then poke the value away.  WLDMOD will, however,
			call CHANGE to give DFTEMP a correct planning value.
		;

	HALRCLASS (CENTER) (RVAR CF;RCELL CLAUSES);
	HALRCLASS (STOP) (RVAR CF);

	HALRCLASS (CMON) (RPTR(EXPRN,VARIABLE) CONDITION; RSTMNT CONCLUSION;
		INTEGER OFFSET);
	HALRCLASS (CMABLE) (RPTR(CMON,LBLVAR) WHAT;INTEGER FLAG);
		! (FLAG = TRUE) => enable, else disable;

	HALRCLASS (DURATION) (REXPR TIME; INTEGER TIME_RELN);
		! Note:  the time relations are the following:
		0	no relation given
		1	> (that is, a lower bound)
		2	< (that is, an upper bound)
		3	= (that is, an exact bound)
		;
	HALRCLASS (VIA) (REXPR PLACE,VELOC; RPTR(DURATION) TIME;
				RSTMNT CODE;RPTR(DEXPR) ACTPLACE);
		! ACTPLACE gives where this VIA must actually go thru. ;

	HALRCLASS (ARRIVAL) (REXPR THRU; RPTR(DEXPR) ACTPLACE);
	HALRCLASS (DEPARTURE) (REXPR THRU; RPTR(DEXPR) ACTPLACE);

	HALRCLASS (VELOCITY) (REXPR VELOC);

	HALRCLASS (FORCE) (REXPR FDIRECT, MDIRECT; INTEGER OFFSET);

	HALRCLASS (OPENING) (REXPR VAL);

	! Assertions & compile-time conditionals;

	HALRCLASS (NOMV)(REXPR E;ITEMVAR WLD);
	HALRCLASS (BINDV)(RPTR(VARIABLE) VAR;RANY RESULT);

	HALRCLASS (SFACT)(RCELL PATT;RPTR(FACT) FACT);
	HALRCLASS (AFACT)(INTEGER RELN;REXPR LEFT,RIGHT);
	HALRCLASS (ASSERT)(ITEMVAR WLD;RPTR(SFACT,AFACT) FACT);
	HALRCLASS (DENY)(ITEMVAR WLD;RPTR(SFACT,AFACT) FACT);
	HALRTYPE (PAS);

	HALRCLASS (CIF) (REXPR COND; RCELL THN, ELS);

	! Totally miscellaneous things;
	HALRCLASS (IDENT)(RANY ITEMVAR ID); ! used by GOBBLE;
	HALRCLASS (COMMNT) (RANY HESAYS);

	HALRECTERNAL RCLASS AFXDATA(RVAR A,B,T,YOUNGEST;
				    REXPR INVT;
				    RPTR(CALCULATOR) C1,C2;
				    RPTR(CHANGER) CHG);

! data types;

DEFINE  DEFDTYPE(MNE,XXX) "<>" = <
	REDEFINE NDTYPES=NDTYPES+1;
	ASSIGNC XXX = CVPS(MNE)&"_DTYPE";
	DEFINE XXX = NDTYPES>;

DEFINE NDTYPES=-1;
DEFDTYPE(INVALID);	! 0 is invalid;
DEFDTYPE(SVAL);		! scalar;
DEFDTYPE(V3ECT);	! 3 vector;
DEFDTYPE(ROTN);		! rotation;
DEFDTYPE(TRANS);	! transform matrix;
DEFDTYPE(FRAME);	! frame;

DEFDTYPE(ATOM);		! an "atom" -- symbolic only;
DEFDTYPE(STATEMENT);	! a "statement" variable;
DEFDTYPE(CLAUSE);	! a "clause" variable;
DEFDTYPE(EXPRESSION);	! an "expression" variable;

DEFDTYPE(EVENT);	! an "event" variable;
DEFDTYPE(WORLD);	! a "world" variable;

! note: Labels get loaded up with the semantics of the thing 
	pointed to.
;

DEFDTYPE(STMLAB);	! statement label;
DEFDTYPE(CLCLAB);	! calculator label;
DEFDTYPE(CHGLAB);	! changer label;
DEFDTYPE(OMNLAB);	! on-monitor label;
! operators for expressions;


IFCR HALRECSW THENC
DEFINE  DEFOP(MNE,XXX,YYY) "<>" = <
	REDEFINE NOPS=NOPS+1;
	ASSIGNC XXX = CVPS(MNE)&"_OP";
	ASSIGNC YYY = """"&CVPS(MNE)&"""";
	YYY,
	DEFINE XXX = NOPS>;
PRELOAD_WITH 
ELSEC
DEFINE  DEFOP(MNE,XXX) "<>" = <
	REDEFINE NOPS=NOPS+1;
	ASSIGNC XXX = CVPS(MNE)&"_OP";
	DEFINE XXX = NOPS>;
ENDC

DEFINE OPBRK(MXID,MNID,XXX) "<>" = <
	ASSIGNC XXX = "MAX_"&CVPS(MXID)&"_OP";
	DEFINE XXX = NOPS;
	ASSIGNC XXX = "MIN_"&CVPS(MNID)&"_OP";
	DEFINE XXX = NOPS+1>;

!  This list updated 6/30/75 by RF & 7/25/76 by ARG;
DEFINE NOPS=-1;				! Return nothing;
DEFOP(INVALID);
DEFOP(NO);		! no-op;
OPBRK(NO,SVAL);				! Return scalars;
DEFOP(SADD);		! s+s;
DEFOP(SSUB);		! s-s;
DEFOP(SNEG);		! -s;
DEFOP(SMUL);		! s*s;
DEFOP(SDIV);		! s/s;
DEFOP(SLT);		! S<S;
DEFOP(SEQ);		! S=S;
DEFOP(SLE);		! S≤S;
DEFOP(SGE);		! S≥S;
DEFOP(SNE);		! S≠S;
DEFOP(SGT);		! S>S;
DEFOP(AND);		! S∧S;
DEFOP(OR);		! S∨S;
DEFOP(NOT);		! ¬S;
DEFOP(VMAGN);		! |v|;
DEFOP(VDOT);		! v.v;
DEFOP(RMAGN);		! rotation angle of r;
OPBRK(SVAL,V3ECT);			! Return vectors;
DEFOP(VMAKE);		! vector(s,s,s);
DEFOP(SVMUL);		! s*v;
DEFOP(VADD);		! v+v;
DEFOP(VSUB);		! v-v;
DEFOP(RVMUL);		! r*v;
DEFOP(TVMUL);		! t*v;
DEFOP(UVECT);		! v/magn(v);
DEFOP(AXIS);		! rotation axis of r;
DEFOP(POS);		! position part of a trans;
OPBRK(V3ECT,ROTN);			! Return rotns;
DEFOP(AXW_ROTN);	! rotation of s radians about v;
DEFOP(ORIENT);		! rotation part of t;
DEFOP(RRMUL);		! r*r;
OPBRK(ROTN,TRANS);			! Return transes;
DEFOP(TMAKE);		! trans(r,v);
DEFOP(FTOF);		! f → f;	!  *** kill this soon ***;
DEFOP(TVADD);		! t+v;
DEFOP(TVSUB);		! t-v;
DEFOP(TTMUL);		! t*t;
DEFOP(TINVRT);		! inverse(t);
DEFOP(DEPR);		! deproach(f);
OPBRK(TRANS,FRAME);			! Return frames;
DEFOP(FMAKE);		! frame(R,v);
DEFOP(TFMAKE);		! frame(T);
OPBRK(FRAME,LAST);
DEFOP(LAST);				! Never return;
IFCR HALRECSW THENC
"INVALID";INTERNAL STRING ARRAY OP_MNE[0:LAST_OP+1];
ELSEC
EXTERNAL STRING ARRAY OP_MNE[0:LAST_OP+1];
ENDC

! predeclared variables & internal system variables;

IFCR HALRECSW THENC
	DEFINE PDVSW = [TRUE];  !  RF.  I couldn't find global BARM, etc.;
	DEFINE HALITM(ID,SID,NARG,INID) "<>" = 
		<IFCR LENGTH(CVPS(SID)) THENC 
			DEFINE ID = CVPS(SID);
			ENDC
		INTERNAL ITEMVAR ID;
		ASSIGNC INID = "INI_"&CVPS(ID);
		SIMPLE PROCEDURE INID;
			BEGIN
			ID←CVSI(CVPS(ID),HALIFG);
			IF HALIFG THEN
				NEW_PNAME(ID←NEW NARG,CVPS(ID));
			END;
		REQUIRE INID INITIALIZATION>;
	INTEGER HALIFG;
		
ELSEC
	DEFINE HALITM(ID,SID,NARG,INID) "<>" = 
		<IFCR LENGTH(CVPS(SID)) THENC 
			DEFINE ID = CVPS(SID);
			ENDC
		EXTERNAL ITEMVAR ID>;
ENDC



IFCR ¬DECLARATION(PDVSW) THENC DEFINE PDVSW = [FALSE]; ENDC

IFCR PDVSW THENC
    DEFINE PDV(ID,HDT,OFFST,INID) "<>" =
	< 
	  INTERNAL RPTR(VARIABLE) ID;
	  IFCR ¬LENGTH(CVPS(INID)) THENC ASSIGNC INID="INI_"&CVPS(ID); ENDC
	  PROCEDURE INID;
		BEGIN
		RANY ITEMVAR IV;
		EXTERNAL RPTR(VARIABLE) PROCEDURE NEW_VAR(ITEMVAR IV;INTEGER DT;
								RPTR(BLOCK) BID);
		IV←NEW(NULL_RECORD);
		NEW_PNAME(IV,"ID");
		∂(IV)←ID←NEW_VAR(IV,HDT,NULL_RECORD);
		VARIABLE:OFFSET[ID] ← OFFST;
		END;
	  REQUIRE INID INITIALIZATION>;
ELSEC

    DEFINE PDV(ID,HDT,OFFST) "<>" =
	< EXTERNAL RPTR(VARIABLE) ID >;

ENDC

PDV(YARM,FRAME_DTYPE,'10);
PDV(YHAND,SVAL_DTYPE,'12);
PDV(BARM,FRAME_DTYPE,'14);
PDV(BHAND,SVAL_DTYPE,'16);
PDV(NEWV,FRAME_DTYPE,'0);  ! Added by RF.  Never use the offset;
PDV(OLDV,FRAME_DTYPE,'0);  ! Added by RF.  Never use the offset;
PDV(BDEPROACH,FRAME_DTYPE,'30);	! added by arg;
PDV(YDEPROACH,FRAME_DTYPE,'32);	! added by arg;

! some standard pattern things;

DEFINE AFFIXED "<>" = <ATCHD>;

PDV(AFFIXED,ATOM_DTYPE,0);
PDV(WAS_AFFIXED,ATOM_DTYPE,0);
PDV(RIGIDLY,ATOM_DTYPE,0);
PDV(NONRIGIDLY,ATOM_DTYPE,0);
PDV(DEPROACH,ATOM_DTYPE,0);


! Patterns:

    [ AFFIXED,f1,f2,byvar,rgf ]
	rgf = RIGIDLY or NONRIGIDLY

;

REQUIRE UNSTACK_DELIMITERS;
HALRECEND